package cn.iocoder.yudao.position.service.impl;

import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.position.entity.PositionCategoryDO;
import cn.iocoder.yudao.position.mapper.PositionCategoryMapper;
import cn.iocoder.yudao.position.service.PositionCategoryService;
import cn.iocoder.yudao.position.vo.PositionCategoryPageReqVO;
import cn.iocoder.yudao.position.vo.PositionCategorySaveReqVO;
import cn.iocoder.yudao.position.vo.PositionCategoryTreeNodeVO;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.system.enums.ErrorCodeConstants.POSITION_COMPANY_MISMATCH;

/**
 * 字典-行业类别表(树形结构) Service 实现类
 *
 * @author 超级管理员
 */
@Service
@Validated
public class PositionCategoryServiceImpl implements PositionCategoryService {

    @Resource
    private PositionCategoryMapper positionCategoryMapper;

    @Override
    public Long createCategory(PositionCategorySaveReqVO createReqVO) {
        // 插入
        PositionCategoryDO category = BeanUtils.toBean(createReqVO, PositionCategoryDO.class);
        positionCategoryMapper.insert(category);
        // 返回
        return category.getCategoryId();
    }

    @Override
    public void updateCategory(PositionCategorySaveReqVO updateReqVO) {
        // 校验存在
        validateCategoryExists(updateReqVO.getCategoryId());
        // 更新
        PositionCategoryDO updateObj = BeanUtils.toBean(updateReqVO, PositionCategoryDO.class);
        positionCategoryMapper.updateById(updateObj);
    }

    @Override
    public void deleteCategory(Long id) {
        // 校验存在
        validateCategoryExists(id);
        // 删除
        positionCategoryMapper.deleteById(id);
    }

    private void validateCategoryExists(Long id) {
        if (positionCategoryMapper.selectById(id) == null) {
            throw exception(POSITION_COMPANY_MISMATCH);
        }
    }

    @Override
    public PositionCategoryDO getCategory(Long id) {
        return positionCategoryMapper.selectById(id);
    }

    @Override
    public PageResult<PositionCategoryDO> getCategoryPage(PositionCategoryPageReqVO pageReqVO) {
        return positionCategoryMapper.selectPage(pageReqVO);
    }

    @Override
    public List<PositionCategoryDO> getList() {
        return positionCategoryMapper.selectList();
    }

    @Override
    /**
     * 构建行业类别树形结构
     *
     * @param categories 所有行业类别列表
     * @return 树形结构
     */ public List<PositionCategoryTreeNodeVO> buildCategoryTree(List<PositionCategoryDO> categories) {
        if (CollectionUtils.isEmpty(categories)) {
            return Collections.emptyList();
        }

        // 转换为 Map 结构，key 是 categoryId
        Map<Long, PositionCategoryTreeNodeVO> nodeMap = categories.stream().map(category -> {
            PositionCategoryTreeNodeVO node = new PositionCategoryTreeNodeVO();
            node.setCategoryId(category.getCategoryId());
            node.setParentId(category.getParentId());
            node.setCategoryName(category.getCategoryName());
            node.setCategoryCode(category.getCategoryCode());
            node.setLevel(category.getLevel());
            node.setOrderNum(category.getOrderNum());
            node.setStatus(category.getStatus());
            return node;
        }).collect(Collectors.toMap(PositionCategoryTreeNodeVO::getCategoryId, node -> node));

        // 构建树形结构
        List<PositionCategoryTreeNodeVO> tree = new ArrayList<>();
        for (PositionCategoryTreeNodeVO node : nodeMap.values()) {
            if (node.getParentId() == 0L) {
                // 一级节点
                tree.add(node);
            } else {
                // 子节点，添加到父节点的 children 中
                PositionCategoryTreeNodeVO parentNode = nodeMap.get(node.getParentId());
                if (parentNode != null) {
                    if (parentNode.getChildren() == null) {
                        parentNode.setChildren(new ArrayList<>());
                    }
                    parentNode.getChildren().add(node);
                }
            }
        }

        // 对每个层级的节点按 orderNum 排序
        sortTreeNodes(tree);
        return tree;
    }

    /**
     * 递归排序树节点
     *
     * @param nodes 节点列表
     */
    private void sortTreeNodes(List<PositionCategoryTreeNodeVO> nodes) {
        if (CollectionUtils.isEmpty(nodes)) {
            return;
        }

        // 按 orderNum 排序当前层级
        nodes.sort(Comparator.comparingInt(PositionCategoryTreeNodeVO::getOrderNum));

        // 递归排序子节点
        for (PositionCategoryTreeNodeVO node : nodes) {
            if (node.getChildren() != null) {
                sortTreeNodes(node.getChildren());
            }
        }
    }
}